home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 4 / Apprentice-Release4.iso / Source Code / Libraries / DCLAP 4j / corelib / ncbifile.c < prev    next >
Encoding:
Text File  |  1995-12-17  |  29.9 KB  |  1,210 lines  |  [TEXT/R*ch]
  1. /*   ncbifile.c
  2. * ===========================================================================
  3. *
  4. *                            PUBLIC DOMAIN NOTICE                          
  5. *               National Center for Biotechnology Information
  6. *                                                                          
  7. *  This software/database is a "United States Government Work" under the   
  8. *  terms of the United States Copyright Act.  It was written as part of    
  9. *  the author's official duties as a United States Government employee and 
  10. *  thus cannot be copyrighted.  This software/database is freely available 
  11. *  to the public for use. The National Library of Medicine and the U.S.    
  12. *  Government have not placed any restriction on its use or reproduction.  
  13. *                                                                          
  14. *  Although all reasonable efforts have been taken to ensure the accuracy  
  15. *  and reliability of the software and data, the NLM and the U.S.          
  16. *  Government do not and cannot warrant the performance or results that    
  17. *  may be obtained by using this software or data. The NLM and the U.S.    
  18. *  Government disclaim all warranties, express or implied, including       
  19. *  warranties of performance, merchantability or fitness for any particular
  20. *  purpose.                                                                
  21. *                                                                          
  22. *  Please cite the author in any work or product based on this material.   
  23. *
  24. * ===========================================================================
  25. *
  26. * File Name:  ncbifile.c
  27. *
  28. * Author:  Gish, Kans, Ostell, Schuler
  29. *
  30. * Version Creation Date:   3/4/91
  31. *
  32. * $Revision: 2.35 $
  33. *
  34. * File Description: 
  35. *     portable file routines
  36. *
  37. * Modifications:  
  38. * --------------------------------------------------------------------------
  39. * Date     Name        Description of modification
  40. * -------  ----------  -----------------------------------------------------
  41. * 04-15-93 Schuler     Changed _cdecl to LIBCALL
  42. * 12-20-93 Schuler     Converted ErrPost to ErrPostEx
  43. *
  44. * ==========================================================================
  45. */
  46.  
  47. #undef  THIS_MODULE
  48. #define THIS_MODULE g_corelib
  49. #undef  THIS_FILE
  50. #define THIS_FILE  _this_file
  51.  
  52. #include <ncbi.h>
  53. #include <ncbiwin.h>
  54.  
  55. #if (defined(OS_DOS) && defined(WIN_DUMB))
  56. #endif
  57.  
  58. #ifdef OS_MAC
  59. #include <Errors.h>
  60. #include <GestaltEqu.h>
  61. #include <Folders.h>
  62. #include <Strings.h>
  63. #endif
  64.  
  65. #ifdef OS_UNIX_SUN
  66. #include <sys/file.h>
  67. #include <sun/dkio.h>
  68. #include <sys/buf.h>
  69. #include <scsi/targets/srdef.h>
  70. #define DEFAULT_CDROM "/dev/sr0"
  71. #define DEFAULT_RAW_CDROM "/dev/rsr0"
  72. #endif
  73.  
  74. #ifdef PROC_MIPS
  75. #define DEFAULT_CDROM "/dev/scsi/sc0d4l0"
  76. #endif
  77.  
  78. #ifdef OS_UNIX
  79. #ifndef DEFAULT_CDROM
  80. #define DEFAULT_CDROM "/dev/cdrom"
  81. #endif
  82. #endif
  83.  
  84. #ifdef WIN_MSWIN
  85. static char * localbuf;
  86. static int filecount;
  87. #define LOCAL_BUF_SIZE 2*KBYTE
  88. #endif
  89.  
  90. #if (defined(OS_DOS) || defined (OS_NT))
  91. #ifdef WIN_DUMB
  92. #include <fcntl.h>         /* for setmode() */
  93. #include <io.h>
  94. #endif
  95. #ifdef COMP_MSC
  96. #include <direct.h>
  97. #ifndef mkdir
  98. #define mkdir _mkdir
  99. #endif
  100. #ifndef stat
  101. #define stat _stat
  102. #endif
  103. #endif
  104. #ifdef COMP_BOR
  105. #include <dir.h>
  106. #endif
  107. #ifdef COMP_SYMC
  108. #include <dir.h>
  109. #endif
  110. #endif
  111.  
  112. #ifdef OS_VMS
  113. #include <stat.h>   /* fstat function and buffer definition */
  114. #include <fab.h>    /* RFM (Record Format) definitions      */
  115. #ifndef DEFAULT_CDROM
  116. #define DEFAULT_CDROM "cdrom:"
  117. #endif
  118. #endif
  119.  
  120. extern char *g_corelib;
  121. static char * _this_file = __FILE__;
  122.  
  123.  
  124. /*****************************************************************************
  125. *
  126. *   Macintosh file utilities
  127. *
  128. *****************************************************************************/
  129.  
  130. #ifdef OS_MAC
  131. static short Nlm_MacGetVRefNum (Nlm_CharPtr pathname, OSErr *errptr)
  132.  
  133. {
  134.   OSErr           err;
  135.   FILE            *f;
  136.   Nlm_Char        filename [FILENAME_MAX];
  137.   Nlm_Char        path [256];
  138.   HParamBlockRec  pbh;
  139.   Nlm_CharPtr     ptr;
  140.  
  141.   memset (&pbh, 0, sizeof (HParamBlockRec));
  142.   Nlm_StringNCpy (path, pathname, sizeof (path) - 1);
  143.   ptr = Nlm_StringRChr (path, (int) DIRDELIMCHR);
  144.   if (ptr != NULL) {
  145.     ptr++;
  146.     Nlm_StringNCpy (filename, ptr, sizeof (filename) - 1);
  147.     *ptr = '\0';
  148. #if defined(COMP_MPW) || defined(COMP_CODEWAR)
  149.     c2pstr ((char *) path);
  150. #else
  151. #ifdef COMP_THINKC
  152.     CtoPstr ((char *) path);
  153. #endif
  154. #endif
  155.     pbh.volumeParam.ioNamePtr = (StringPtr) path;
  156.     pbh.volumeParam.ioVolIndex = -1;
  157.     err = PBHGetVInfo (&pbh, FALSE);
  158.     if (errptr != NULL) {
  159.       *errptr = err;
  160.     }
  161.     return pbh.volumeParam.ioVRefNum;
  162.   } else {
  163.     if (errptr != NULL) {
  164.       *errptr = noErr;
  165.     }
  166.     return 0;
  167.   }
  168. }
  169.  
  170. static long Nlm_MacGetDirID (Nlm_CharPtr pathname, short newVRefNum, OSErr *errptr)
  171.  
  172. {
  173.   OSErr           err;
  174.   FILE            *f;
  175.   Nlm_Char        path [256];
  176.   CInfoPBRec      pbc;
  177.   Nlm_CharPtr     ptr;
  178.  
  179.   memset (&pbc, 0, sizeof (CInfoPBRec));
  180.   Nlm_StringNCpy (path, pathname, sizeof (path) - 1);
  181.   ptr = Nlm_StringRChr (path, (int) DIRDELIMCHR);
  182.   if (ptr != NULL) {
  183.     ptr++;
  184.     Nlm_StringNCpy (path, pathname, sizeof (path) - 1);
  185.     *ptr = '\0';
  186. #if defined(COMP_MPW) || defined(COMP_CODEWAR)
  187.     c2pstr ((char *) path);
  188. #else
  189. #ifdef COMP_THINKC
  190.     CtoPstr ((char *) path);
  191. #endif
  192. #endif
  193.     pbc.dirInfo.ioNamePtr = (StringPtr) path;
  194.     pbc.dirInfo.ioVRefNum = newVRefNum;
  195.     err = PBGetCatInfo (&pbc, FALSE);
  196.     if (errptr != NULL) {
  197.       *errptr = err;
  198.     }
  199.     return pbc.dirInfo.ioDrDirID;
  200.   } else {
  201.     if (errptr != NULL) {
  202.       *errptr = noErr;
  203.     }
  204.     return 0;
  205.   }
  206. }
  207.  
  208. static OSErr Nlm_SetDefault (short newVRefNum, long newDirID, short *oldVRefNum, long *oldDirID)
  209.  
  210. {
  211.   OSErr  error;
  212.   long   procID;
  213.  
  214.   error = HGetVol (NULL, oldVRefNum, oldDirID);
  215.   if (error == noErr) {
  216.     error = HSetVol (NULL, newVRefNum, newDirID);
  217.   }
  218.   return (error);
  219. }
  220.  
  221. static OSErr Nlm_RestoreDefault (short oldVRefNum, long oldDirID)
  222.  
  223. {
  224.   OSErr  error;
  225.   short  defaultVRefNum;
  226.   long   defaultDirID;
  227.   long   defaultProcID;
  228.  
  229.   error = GetWDInfo (oldVRefNum, &defaultVRefNum, &defaultDirID, &defaultProcID);
  230.   if (error == noErr) {
  231.     if (defaultDirID != fsRtDirID) {
  232.       error = SetVol (NULL, oldVRefNum);
  233.     } else {
  234.       error = HSetVol (NULL, oldVRefNum, oldDirID);
  235.     }
  236.   }
  237.   return (error);
  238. }
  239. #endif
  240.  
  241. /*****************************************************************************
  242. *
  243. *   FileOpen(filename, mode)
  244. *     if (filename == "stdin" or "stdout" or "stderr"
  245. *           returns those predefined
  246. *           streams on non-windowing systems)
  247. *
  248. *****************************************************************************/
  249.  
  250. static Nlm_FileOpenHook _hookFile = NULL;
  251.  
  252. #ifdef COMP_MPW
  253. /*
  254. *  MPWOptimizationErrorBypass was called in order to avoid an apparent MPC C
  255. *  compiler optimization problem that resulted in the newDirID value sometimes
  256. *  appearing to be 0.  Placing any debugging statement (or this dummy function)
  257. *  after the statement that gets newDirID and before the statement that uses it
  258. *  originally appeared to fix the problem.  Upon further investigation, it turns
  259. *  out to be a problem with a UNIX to Mac file server product.  The problem did
  260. *  not occur when compiling under THINK C.
  261. */
  262.  
  263. static Nlm_Int2 Nlm_MPWOptimizationErrorBypass (short newVRefNum, long newDirID)
  264. {
  265. }
  266.  
  267. /*
  268. *  In MPW, if a temporary file is written first, without being created, it is
  269. *  created on the hard disk, rather than in the appropriate path.  This code
  270. *  creates the file in the desired location.
  271. */
  272.  
  273. static void Nlm_MPWCreateOutputFile (Nlm_CharPtr pathname, Nlm_CharPtr filename)
  274.  
  275. {
  276.   OSErr     err;
  277.   FILE      *f;
  278.   Nlm_Char  temp [256];
  279.  
  280.   f = fopen (filename, "r");
  281.   if (f == NULL) {
  282.     Nlm_StringNCpy (temp, pathname, sizeof (temp));
  283. #if defined(COMP_MPW) || defined(COMP_CODEWAR)
  284.   c2pstr ((char *) temp);
  285. #else
  286. #ifdef COMP_THINKC
  287.   CtoPstr ((char *) temp);
  288. #endif
  289. #endif
  290.     err = Create ((StringPtr) temp, 0, '    ', 'TEXT');
  291.   } else {
  292.     fclose (f);
  293.   }
  294. }
  295.  
  296. static FILE * LIBCALL  Nlm_MPWFileOpen (Nlm_CharPtr pathname, Nlm_CharPtr mode)
  297.  
  298. {
  299.   Nlm_Boolean  createfile;
  300.   OSErr        err;
  301.   FILE         *f;
  302.   long         newDirID;
  303.   short        newVRefNum;
  304.   long         oldDirID;
  305.   short        oldVRefNum;
  306.   Nlm_CharPtr  ptr;
  307.  
  308.   newVRefNum = Nlm_MacGetVRefNum (pathname, &err);
  309.   newDirID = Nlm_MacGetDirID (pathname, newVRefNum, &err);
  310.   ptr = Nlm_StringRChr (pathname, (int) DIRDELIMCHR);
  311.   createfile = (Nlm_Boolean) (strchr (mode, 'w') != NULL);
  312.   if (ptr != NULL) {
  313.     ptr++;
  314.     Nlm_MPWOptimizationErrorBypass (newVRefNum, newDirID);
  315.     err = Nlm_SetDefault (newVRefNum, newDirID, &oldVRefNum, &oldDirID);
  316.     if (createfile) {
  317.       Nlm_MPWCreateOutputFile (pathname, ptr);
  318.     }
  319.     f = fopen (ptr, mode);
  320.     err = Nlm_RestoreDefault (oldVRefNum, oldDirID);
  321.   } else {
  322.     if (createfile) {
  323.       Nlm_MPWCreateOutputFile (pathname, pathname);
  324.     }
  325.     f = fopen (pathname, mode);
  326.   }
  327.   return f;
  328. }
  329. #endif
  330.  
  331. FILE * LIBCALL  Nlm_FileOpen (const char *filename, const char *mode)
  332. {
  333.   FILE      *f;
  334. #ifdef OS_MAC
  335.   OSType    fCreator;
  336.   Nlm_Int2  fError;
  337.   FInfo     fInfo;
  338.   OSType    fType;
  339.   Nlm_Char  temp [256];
  340. #endif
  341.  
  342.   if (_hookFile != NULL) {
  343.     return _hookFile (filename, mode);
  344.   }
  345.   f = NULL;
  346. #ifdef WIN_DUMB
  347.   if (! StringCmp ("stdin", filename)) {
  348. #ifdef OS_DOS
  349.     if (strchr (mode, 'b') != NULL) {
  350.       setmode (fileno (stdin), O_BINARY);
  351.     }
  352. #endif
  353.     f = stdin;
  354.   } else if (! StringCmp ("stdout", filename)) {
  355. #ifdef OS_DOS
  356.     if (strchr (mode, 'b') != NULL) {
  357.       setmode (fileno (stdout), O_BINARY);
  358.     }
  359. #endif
  360.     f = stdout;
  361.   } else if (! StringCmp("stderr", filename)) {
  362.     f = stderr;
  363.   } else {
  364. #ifdef OS_VMS
  365.     f = fopen (filename, mode);
  366.     if (f) {
  367.       stat_t statbuf;
  368.       if ( fstat(fileno(f),&statbuf) == 0 ) {
  369.         if (statbuf.st_fab_rfm == FAB$C_UDF ) {
  370.           fclose(f);
  371.           f = fopen(filename,mode,"ctx=stm");
  372.         }
  373.       }
  374.     }
  375. #else
  376.     f = fopen (filename, mode);
  377. #endif
  378.   }
  379. #else
  380. #ifdef OS_MAC
  381.   Nlm_StringNCpy (temp, filename, sizeof (temp));
  382. #if defined(COMP_MPW) || defined(COMP_CODEWAR)
  383.     c2pstr ((char *) temp);
  384. #else
  385. #ifdef COMP_THINKC
  386.     CtoPstr ((char *) temp);
  387. #endif
  388. #endif
  389.   fError = GetFInfo ((StringPtr) temp, 0, &fInfo);
  390.   if (fError == 0) {
  391.     fCreator = fInfo.fdCreator;
  392.     fType = fInfo.fdType;
  393.   } else {
  394.     if (strchr (mode, 'b') != NULL) {
  395.       fType = '    ';
  396.     } else {
  397.       fType = 'TEXT';
  398.     }
  399.     fCreator = '    ';
  400.   }
  401. #endif
  402. #ifdef COMP_MPW
  403.   {
  404.     Nlm_Char  localmode [16];
  405.     Nlm_Char  path [PATH_MAX];
  406.     Nlm_StringNCpy (path, filename, sizeof (path) - 1);
  407.     Nlm_StringNCpy (localmode, mode, sizeof (localmode) - 1);
  408.     f = Nlm_MPWFileOpen (path, localmode);
  409.   }
  410. #else
  411. #ifdef OS_VMS
  412.  
  413.     f = fopen (filename, mode);
  414.     if (f) {
  415.       if ( fstat(fileno(f),&statbuf) == 0 ) {
  416.         if (statbuf.st_fab_rfm == FAB$C_UDF ) {
  417.           fclose(f);
  418.           f = fopen(filename,mode,"ctx=stm");
  419.         }
  420.       }
  421.     }
  422. #else
  423.   f = fopen (filename,mode);
  424. #endif
  425. #endif
  426. #ifdef OS_MAC
  427.   fError = GetFInfo ((StringPtr) temp, 0, &fInfo);
  428.   if (fError == 0) {
  429.     fInfo.fdCreator = fCreator;
  430.     fInfo.fdType = fType;
  431.     fError = SetFInfo ((StringPtr) temp, 0, &fInfo);
  432.   }
  433. #endif
  434. #endif
  435.  
  436.     if (f == NULL)
  437.         ErrPostEx(SEV_INFO,E_File,E_FOpen,"FileOpen(\"%s\",\"%s\") failed",filename,mode);
  438.         
  439.     return f;
  440. }
  441.  
  442. /*****************************************************************************
  443. *
  444. *   SetFileOpenHook(hook)
  445. *
  446. *****************************************************************************/
  447.  
  448. void LIBCALL Nlm_SetFileOpenHook (Nlm_FileOpenHook hook)
  449. {
  450.     _hookFile = hook;
  451. }
  452.  
  453. /*****************************************************************************
  454. *
  455. *   FileClose(fp)
  456. *
  457. *****************************************************************************/
  458.  
  459. void LIBCALL  Nlm_FileClose (FILE *stream)
  460. {
  461.     if (stream == NULL)
  462.         return;
  463.     
  464. #ifdef WIN_DUMB
  465.     if (stream==stdin || stream==stdout || stream==stderr)
  466.     {
  467. #ifdef OS_DOS
  468.         setmode(fileno(stream),O_TEXT);
  469. #endif
  470.     }
  471.     else 
  472.     {
  473.         fclose(stream);
  474.     }
  475. #else
  476.     fclose(stream);
  477. #endif
  478. }
  479.  
  480. /*****************************************************************************
  481. *
  482. *   FileRead(buf, size, fp)
  483. *
  484. *****************************************************************************/
  485. #ifdef WIN16
  486. #include <dos.h> /* dos.h defines the FP_SEG macro */
  487. #endif
  488.  
  489. Nlm_sizeT LIBCALL  Nlm_FileRead (void *ptr, Nlm_sizeT size, Nlm_sizeT n, FILE *stream)
  490. {
  491.     if ((n != 0) && ((Nlm_Int4)(SIZE_MAX / (Nlm_Int4) n) < (Nlm_Int4) size))
  492.         ErrPostEx(SEV_WARNING,E_Programmer,0,"FileRead: size > SIZE_MAX");
  493.     else if (ptr != NULL && stream != NULL)
  494.         return fread(ptr,size,n,stream);
  495.     return 0;
  496. }
  497.  
  498. /*****************************************************************************
  499. *
  500. *   FileWrite(buf, size, fp)
  501. *
  502. *****************************************************************************/
  503.  
  504. Nlm_sizeT LIBCALL  Nlm_FileWrite (const void *ptr, Nlm_sizeT size, Nlm_sizeT n, FILE *stream)
  505. {
  506.     if ((n != 0) && ((Nlm_Int4)(SIZE_MAX / (Nlm_Int4) n) < (Nlm_Int4) size))
  507.         ErrPostEx(SEV_WARNING,E_Programmer,0,"FileWrite:  size > SIZE_MAX");
  508.     else if (ptr != NULL && stream != NULL)
  509.     {
  510.         Nlm_sizeT cnt = fwrite(ptr,size,n,stream);
  511.         if (cnt != n)
  512.             ErrPostEx(SEV_FATAL,E_File,E_FWrite,"File write error");
  513.         return cnt;
  514.       }
  515.     return 0;
  516. }
  517.  
  518. /*****************************************************************************
  519. *
  520. *   FilePuts(ptr, fp)
  521. *
  522. *****************************************************************************/
  523. int LIBCALL  Nlm_FilePuts (const char *ptr, FILE *fp)
  524. {
  525.     int retval;
  526.  
  527.     if ((ptr == NULL) || (fp == NULL))
  528.         return EOF;
  529.     if ((retval = fputs(ptr,fp)) ==EOF)
  530.         ErrPostEx(SEV_FATAL,E_File,E_FWrite,"File write error");
  531.     return retval;
  532. }
  533.  
  534. /*****************************************************************************
  535. *
  536. *   FileGets()
  537. *
  538. *****************************************************************************/
  539. char * LIBCALL  Nlm_FileGets (Nlm_CharPtr ptr, Nlm_sizeT size, FILE *fp)
  540. {
  541.     if ((ptr == NULL) || (size <= 0) || (fp == NULL))
  542.         return NULL;
  543.     return fgets(ptr,size,fp);
  544. }
  545.  
  546.  
  547. /*****************************************************************************
  548. *
  549. *   FileBuildPath()
  550. *
  551. *****************************************************************************/
  552. Nlm_CharPtr LIBCALL  Nlm_FileBuildPath (Nlm_CharPtr root, Nlm_CharPtr sub_path, Nlm_CharPtr filename)
  553.  
  554. {
  555.     Nlm_CharPtr tmp;
  556.     Nlm_Boolean dir_start = FALSE;
  557. #ifdef OS_VMS
  558.   Nlm_Boolean had_root = FALSE;
  559. #endif
  560.  
  561.     if (root == NULL)              /* no place to put it */
  562.         return NULL;
  563.  
  564.     tmp = root;
  565.     if (*tmp != '\0')                /* if not empty */
  566.     {
  567. #ifndef OS_VMS
  568.         dir_start = TRUE;
  569. #else
  570.         had_root = TRUE;
  571. #endif
  572.         while (*tmp != '\0')
  573.         {
  574. #ifdef OS_VMS
  575.             if (*tmp == '[')
  576.                 dir_start = TRUE;
  577. #endif
  578.             tmp++;
  579.         }
  580.  
  581.         if ((*(tmp - 1) != DIRDELIMCHR) && (dir_start))
  582.         {
  583.             *tmp = DIRDELIMCHR;
  584.             tmp++; *tmp = '\0';
  585.         }
  586.     }
  587.  
  588.     if (sub_path != NULL)
  589.     {
  590. #ifdef OS_VMS
  591.         if (dir_start)
  592.         {
  593.             *(tmp-1) = '.';
  594.             if (*sub_path == '[')
  595.                 sub_path++;
  596.         }
  597.         else if ((had_root) && (*sub_path != '['))
  598.         {
  599.             *tmp = '[';
  600.             tmp++; *tmp = '\0';
  601.         }
  602. #else
  603.         if ((dir_start) && (*sub_path == DIRDELIMCHR))
  604.             sub_path++;
  605. #endif
  606.         tmp = StringMove(tmp, sub_path);
  607.         if (*(tmp-1) != DIRDELIMCHR)
  608.         {
  609.             *tmp = DIRDELIMCHR;
  610.             tmp++; *tmp = '\0';
  611.         }
  612.     }
  613.  
  614.     if (filename != NULL)
  615.         StringMove(tmp, filename);
  616.  
  617.     return root;
  618. }
  619.  
  620. /*****************************************************************************
  621. *
  622. *   FileNameFind()
  623. *
  624. *****************************************************************************/
  625. Nlm_CharPtr LIBCALL Nlm_FileNameFind (Nlm_CharPtr pathname)
  626.  
  627. {
  628.   Nlm_CharPtr  filename;
  629.   Nlm_Int2     len;
  630.  
  631.   if (pathname != NULL) {
  632.     len = Nlm_StringLen (pathname);
  633.     filename = &(pathname [len]);
  634.     while (len > 0 && pathname [len - 1] != DIRDELIMCHR) {
  635.       len--;
  636.       filename--;
  637.     }
  638.     return filename;
  639.   } else {
  640.     return NULL;
  641.   }
  642. }
  643.  
  644. /*****************************************************************************
  645. *
  646. *   FileLength()
  647. *
  648. *****************************************************************************/
  649. Nlm_Int4 LIBCALL Nlm_FileLength (Nlm_CharPtr fileName)
  650.  
  651. {
  652. #ifdef OS_MAC
  653.   ParamBlockRec  params;
  654.   OSErr          err;
  655.   Nlm_Char       path [256];
  656.   Nlm_Int4       rsult;
  657.  
  658.   rsult = 0;
  659.   if (fileName != NULL && fileName [0] != '\0') {
  660.     Nlm_StringNCpy (path, fileName, sizeof (path));
  661.     params.fileParam.ioNamePtr = (StringPtr) path;
  662.     params.fileParam.ioVRefNum = 0;
  663.     params.fileParam.ioFDirIndex = 0;
  664. #if defined(COMP_MPW) || defined(COMP_CODEWAR)
  665.     c2pstr ((char *) path);
  666. #else
  667. #ifdef COMP_THINKC
  668.     CtoPstr ((char *) path);
  669. #endif
  670. #endif
  671.     err = PBGetFInfo (¶ms, FALSE);
  672.     if (err == noErr) {
  673.       rsult = params.fileParam.ioFlLgLen;
  674.     }
  675.   }
  676.   return rsult;
  677. #else
  678.   int          err;
  679.   Nlm_Char     local [256];
  680.   Nlm_Int4     rsult;
  681.   struct stat  sbuf;
  682.  
  683.   rsult = 0;
  684.   if (fileName != NULL && fileName [0] != '\0') {
  685.     Nlm_StringNCpy (local, fileName, sizeof (local));
  686.     err = stat (local, &sbuf);
  687.     if (err == 0) {
  688.       rsult = sbuf.st_size;
  689.     }
  690.   }
  691.   return rsult;
  692. #endif
  693. }
  694.  
  695. /*****************************************************************************
  696. *
  697. *   FileDelete()
  698. *
  699. *****************************************************************************/
  700. Nlm_Boolean LIBCALL Nlm_FileRemove (Nlm_CharPtr fileName)
  701.  
  702. {
  703.   Nlm_Char  local [256];
  704.  
  705.   if (fileName != NULL && fileName [0] != '\0') {
  706.     Nlm_StringNCpy (local, fileName, sizeof (local));
  707.     return (Nlm_Boolean) (remove (local) == 0);
  708.   } else {
  709.     return FALSE;
  710.   }
  711. }
  712.  
  713. /*****************************************************************************
  714. *
  715. *   FileRename()
  716. *
  717. *****************************************************************************/
  718. Nlm_Boolean LIBCALL Nlm_FileRename (Nlm_CharPtr oldFileName, Nlm_CharPtr newFileName)
  719.  
  720. {
  721.   Nlm_Char  localnew [256];
  722.   Nlm_Char  localold [256];
  723.  
  724.   if (oldFileName != NULL && oldFileName [0] != '\0'
  725.     && newFileName != NULL && newFileName [0] != '\0') {
  726.     Nlm_StringNCpy (localold, oldFileName, sizeof (localold));
  727.     Nlm_StringNCpy (localnew, newFileName, sizeof (localnew));
  728.     return (Nlm_Boolean) (rename (localold, localnew) == 0);
  729.   } else {
  730.     return FALSE;
  731.   }
  732. }
  733.  
  734. /*****************************************************************************
  735. *
  736. *   FileCreate()
  737. *
  738. *****************************************************************************/
  739. #ifdef WIN_MAC
  740. static OSType Nlm_GetOSType (Nlm_CharPtr str, OSType dfault)
  741.  
  742. {
  743.   OSType  rsult;
  744.  
  745.   rsult = dfault;
  746.   if (str != NULL && str [0] != '\0') {
  747.     rsult = *(OSType*) str;
  748.   }
  749.   return rsult;
  750. }
  751. #endif
  752.  
  753. void LIBCALL Nlm_FileCreate (Nlm_CharPtr fileName, Nlm_CharPtr type, Nlm_CharPtr creator)
  754.  
  755. {
  756.   FILE      *fp;
  757. #ifdef WIN_MAC
  758.   OSType    fCreator;
  759.   Nlm_Int2  fError;
  760.   OSType    fType;
  761.   Nlm_Char  temp [256];
  762. #endif
  763.  
  764.   if (fileName != NULL && fileName [0] != '\0') {
  765. #ifdef WIN_MAC
  766.     if (type != NULL || creator != NULL) {
  767.       fp = Nlm_FileOpen (fileName, "r");
  768.       if (fp == NULL) {
  769.         fType = Nlm_GetOSType (type, 'TEXT');
  770.         fCreator = Nlm_GetOSType (creator, '    ');
  771.         Nlm_StringNCpy (temp, fileName, sizeof (temp));
  772. #if defined(COMP_MPW) || defined(COMP_CODEWAR)
  773.     c2pstr ((char *) temp);
  774. #else
  775. #ifdef COMP_THINKC
  776.     CtoPstr ((char *) temp);
  777. #endif
  778. #endif
  779.         fError = Create ((StringPtr) temp, 0, fCreator, fType);
  780.       } else {
  781.         Nlm_FileClose (fp);
  782.       }
  783.     }
  784. #else
  785.     fp = Nlm_FileOpen (fileName, "w");
  786.     if (fp != NULL) {
  787.       Nlm_FileClose (fp);
  788.     }
  789. #endif
  790.   }
  791. }
  792.  
  793. /*****************************************************************************
  794. *
  795. *   CreateDir(pathname)
  796. *
  797. *****************************************************************************/
  798.  
  799. Nlm_Boolean LIBCALL  Nlm_CreateDir (Nlm_CharPtr pathname)
  800.  
  801. {
  802. #ifdef OS_MAC
  803.   long            dirID;
  804.   Nlm_Char        dirname [FILENAME_MAX];
  805.   OSErr           err;
  806.   Nlm_sizeT          len;
  807.   Nlm_Char        path [PATH_MAX];
  808.   HParamBlockRec  pbh;
  809.   Nlm_CharPtr     ptr;
  810.   short           vRefNum;
  811. #endif
  812. #if (defined(OS_DOS) || defined (OS_NT))
  813.   Nlm_sizeT          len;
  814.   Nlm_Char        path [PATH_MAX];
  815. #endif
  816. #ifdef OS_UNIX
  817.   Nlm_sizeT          len;
  818.   mode_t          oldmask;
  819.   Nlm_Char        path [PATH_MAX];
  820. #endif
  821.   Nlm_Boolean     rsult;
  822.  
  823.   rsult = FALSE;
  824.   if (pathname != NULL && pathname [0] != '\0') {
  825. #ifdef OS_MAC
  826.     Nlm_StringNCpy (path, pathname, sizeof (path) - 1);
  827.     len = Nlm_StringLen (path);
  828.     if (len > 0 && path [len - 1] == DIRDELIMCHR) {
  829.         path [len - 1] = '\0';
  830.     }
  831.     memset (&pbh, 0, sizeof (HParamBlockRec));
  832.     vRefNum = Nlm_MacGetVRefNum (path, &err);
  833.     if (err == noErr) {
  834.       dirID = Nlm_MacGetDirID (path, vRefNum, &err);
  835.       if (err == noErr) {
  836.         ptr = Nlm_StringRChr (path, (int) DIRDELIMCHR);
  837.         if (ptr != NULL) {
  838.           ptr++;
  839.           Nlm_StringNCpy (dirname, ptr, sizeof (dirname) - 1);
  840. #if defined(COMP_MPW) || defined(COMP_CODEWAR)
  841.     c2pstr ((char *) dirname);
  842. #else
  843. #ifdef COMP_THINKC
  844.     CtoPstr ((char *) dirname);
  845. #endif
  846. #endif
  847.           pbh.fileParam.ioNamePtr = (StringPtr) dirname;
  848.           pbh.fileParam.ioVRefNum = vRefNum;
  849.           pbh.fileParam.ioDirID = dirID;
  850.           err = PBDirCreate (&pbh, FALSE);
  851.           rsult = (Nlm_Boolean) (err == noErr || err == dupFNErr);
  852.         }
  853.       }
  854.     }
  855. #endif
  856. #if (defined(OS_DOS) || defined (OS_NT))
  857.     Nlm_StringNCpy (path, pathname, sizeof (path) - 1);
  858.     len = Nlm_StringLen (path);
  859.     if (len > 0 && path [len - 1] == DIRDELIMCHR) {
  860.         path [len - 1] = '\0';
  861.     }
  862.     rsult = (Nlm_Boolean) (mkdir ((char *) path) == 0);
  863.     if (errno == EACCES) { /* it's O.K. if it was already there */
  864.     rsult = TRUE;
  865.     }
  866. #endif
  867. #ifdef OS_UNIX
  868.     oldmask = umask (0000);
  869.     Nlm_StringNCpy (path, pathname, sizeof (path) - 1);
  870.     len = Nlm_StringLen (path);
  871.     if (len > 0 && path [len - 1] == DIRDELIMCHR) {
  872.         path [len - 1] = '\0';
  873.     }
  874.     rsult = (Nlm_Boolean) (mkdir ((char *) path, 0755) == 0);
  875.     if (errno == EEXIST) { /* it's O.K. if it was already there */
  876.     rsult = TRUE;
  877.     }
  878.     umask (oldmask);
  879. #endif
  880. #ifdef OS_VMS
  881.     rsult = (Nlm_Boolean) (mkdir ((char *) pathname, 0755) == 0);
  882. #endif
  883.   }
  884.   return rsult;
  885. }
  886.  
  887. /*****************************************************************************
  888. *
  889. *   TmpNam()
  890. *
  891. *****************************************************************************/
  892. Nlm_CharPtr LIBCALL Nlm_TmpNam (Nlm_CharPtr s)
  893.  
  894. {
  895. #ifdef TEMPNAM_AVAIL
  896.     char *filename;
  897.     static Nlm_Char save_filename[L_tmpnam+30];
  898.  
  899.     /* emulate tmpnam(), except get the benefits of tempnam()'s ability to */
  900.     /* place the files in another directory specified by the environment   */
  901.     /* variable TMPDIR                                                     */
  902.  
  903.     filename = tempnam("", "");
  904.  
  905.     if (s == NULL)
  906.     { /* return pointer to static string */
  907.         if (filename != NULL) {
  908.           strcpy ((char *) save_filename, (char *) filename);
  909.           free ((void *) filename);
  910.         } else {
  911.           save_filename [0] = '\0';
  912.         }
  913.         return save_filename;
  914.     } else {
  915.         if (filename != NULL) {
  916.           strcpy ((char *) save_filename, (char *) filename);
  917.           Nlm_StrCpy (s, save_filename);
  918.           free ((void *) filename);
  919.         } else {
  920.           *s = '\0';
  921.         }
  922.         return s;
  923.     }
  924. #else
  925. #ifdef OS_MAC
  926.     static Nlm_Char  directory [PATH_MAX];
  927.     OSErr        err;
  928.     long         gesResponse;
  929.     long         newDirID;
  930.     short        newVRefNum;
  931.     long         oldDirID;
  932.     short        oldVRefNum;
  933.     CInfoPBRec   params;
  934.     Nlm_Char     temp [PATH_MAX];
  935.     Nlm_CharPtr  tmp;
  936.     Nlm_Boolean  useTempFolder;
  937.     char * filename;
  938.  
  939.     useTempFolder = FALSE;
  940.     if (! Gestalt (gestaltFindFolderAttr, &gesResponse) &&
  941.         (gesResponse & (1 << gestaltFindFolderPresent))) {
  942.       err = FindFolder(kOnSystemDisk, kTemporaryFolderType,
  943.                        kCreateFolder, &newVRefNum, &newDirID);
  944.       if (err == noErr) {
  945.         useTempFolder = TRUE;
  946.         err = Nlm_SetDefault (newVRefNum, newDirID, &oldVRefNum, &oldDirID);
  947.       }
  948.     }
  949.     filename = tmpnam (NULL);
  950.     if (useTempFolder) {
  951.       err = Nlm_RestoreDefault (oldVRefNum, oldDirID);
  952.       temp [0] = '\0';
  953.       params.dirInfo.ioNamePtr = (StringPtr) directory;
  954.       params.dirInfo.ioDrParID = newDirID;
  955.       do {
  956.         params.dirInfo.ioVRefNum = newVRefNum;
  957.         params.dirInfo.ioFDirIndex = -1;
  958.         params.dirInfo.ioDrDirID = params.dirInfo.ioDrParID;
  959.         err = PBGetCatInfo (¶ms, FALSE);
  960. #if defined(COMP_MPW) || defined(COMP_CODEWAR)
  961.   p2cstr ((StringPtr) directory);
  962. #else
  963. #ifdef COMP_THINKC
  964.   PtoCstr ((StringPtr) directory);
  965. #endif
  966. #endif
  967.         Nlm_StringCat (directory, DIRDELIMSTR);
  968.         Nlm_StringCat (directory, temp);
  969.         Nlm_StringCpy (temp, directory);
  970.       } while (params.dirInfo.ioDrDirID != fsRtDirID);
  971.       tmp = Nlm_StringMove (directory, temp);
  972.       tmp = Nlm_StringMove (tmp, (Nlm_CharPtr) filename);
  973.       if (s == NULL) {
  974.           return (Nlm_CharPtr) directory;
  975.       } else {
  976.           s [0] = '\0';
  977.           Nlm_StringCpy (s, directory);
  978.           return s;
  979.       }
  980.     } else {
  981.       if (s == NULL) {
  982.           return (Nlm_CharPtr) filename;
  983.       } else {
  984.           s [0] = '\0';
  985.           Nlm_StringCpy (s, filename);
  986.           return s;
  987.       }
  988.     }
  989. #else
  990.     char * filename;
  991.  
  992.     filename = tmpnam (NULL);
  993.     if (s == NULL) {
  994.         return (Nlm_CharPtr) filename;
  995.     } else {
  996.         s [0] = '\0';
  997.         Nlm_StringCpy (s, filename);
  998.         return s;
  999.     }
  1000. #endif
  1001. #endif
  1002. }
  1003.  
  1004. /*****************************************************************************
  1005. *
  1006. *   CD-ROM Ejection Routines
  1007. *
  1008. *****************************************************************************/
  1009.  
  1010. Nlm_Boolean LIBCALL  Nlm_EjectCd(Nlm_CharPtr sVolume, Nlm_CharPtr deviceName,
  1011.             Nlm_CharPtr rawDeviceName, 
  1012.             Nlm_CharPtr mountPoint,
  1013.             Nlm_CharPtr mountCmd)
  1014. {
  1015.     Nlm_Boolean retval = FALSE;
  1016. #ifdef OS_MAC
  1017.     OSErr err;
  1018.     Nlm_CharPtr prob_area = "Ejection";
  1019.     Nlm_Char    temp [64];
  1020.  
  1021.     
  1022.     Nlm_StringNCpy (temp, sVolume, sizeof (temp) - 1);
  1023.     Nlm_StringCat (temp, ":");
  1024.     if ((err = Eject((StringPtr) NULL, Nlm_MacGetVRefNum(temp, NULL))) == noErr)
  1025.     {
  1026.         if ((err = UnmountVol((StringPtr) NULL, Nlm_MacGetVRefNum(temp, NULL))) == noErr)
  1027.             return TRUE;
  1028.         
  1029.         /* We should still return TRUE if we Eject() successfully but failed to    */
  1030.         /* unmount the volume; however, we need to warn them, because a subsequent */
  1031.         /* GetFInfo() will result in a bus error, at least with System 7.0.        */
  1032.         retval = TRUE;
  1033.         prob_area = "Unmounting";
  1034.     }
  1035.  
  1036.     switch (err) {
  1037.     case bdNamErr:
  1038.     ErrPostEx(SEV_ERROR,E_File,E_CdEject,"%s error - bad volume name %s", prob_area, sVolume);
  1039.     break;
  1040.     case extFSErr:
  1041.     ErrPostEx(SEV_ERROR,E_File,E_CdEject,"%s error - external file system %s", prob_area, sVolume);
  1042.     break;
  1043.     case ioErr:
  1044.     ErrPostEx(SEV_ERROR,E_File,E_CdEject,"%s error - I/O error %s", prob_area, sVolume);
  1045.     break;
  1046.     case nsDrvErr:
  1047.     ErrPostEx(SEV_ERROR,E_File,E_CdEject,"%s error - No such drive %s", prob_area, sVolume);
  1048.     break;
  1049.     case nsvErr:
  1050.     ErrPostEx(SEV_ERROR,E_File,E_CdEject,"%s error - No such volume %s", prob_area, sVolume);
  1051.     break;
  1052.     case paramErr:
  1053.     ErrPostEx(SEV_ERROR,E_File,E_CdEject,"%s error - No default volume %s", prob_area, sVolume);
  1054.     break;
  1055.     }
  1056.     
  1057.     return retval;
  1058. #endif /* OS_MAC */
  1059.  
  1060. #ifdef OS_UNIX
  1061.     char cmd[100];
  1062. #endif
  1063. #ifdef OS_UNIX_SUN
  1064.     int fd;
  1065.  
  1066.     if (deviceName == NULL)
  1067.     {
  1068.         deviceName = DEFAULT_CDROM;
  1069.     }
  1070.  
  1071.     if (rawDeviceName == NULL)
  1072.     {
  1073.         rawDeviceName = DEFAULT_RAW_CDROM;
  1074.     }
  1075.  
  1076.     /* Open the CD-ROM character-based device */
  1077.     if ((fd = open(rawDeviceName, O_RDONLY, 0)) < 0)
  1078.     {
  1079.         ErrPostEx(SEV_ERROR,E_File,E_CdEject,"Ejection error - Unable to open device %s", rawDeviceName);
  1080.         return FALSE;
  1081.     }
  1082.  
  1083.     retval = ioctl(fd, CDROMEJECT, 0) >= 0;
  1084.     close (fd);
  1085.  
  1086.     if (! retval)
  1087.     {
  1088.         ErrPostEx(SEV_ERROR,E_File,E_CdEject,"Ejection error - Ioctl failure for %s", rawDeviceName);
  1089.         return FALSE;
  1090.     }
  1091. #endif /* OS_UNIX_SUN */
  1092.  
  1093. #ifdef OS_UNIX
  1094.     /* Now try to unmount device using (un)mount-script */
  1095.     if (mountCmd != NULL)
  1096.     {
  1097.         sprintf(cmd, "%s -u %s >/dev/null 2>/dev/null", mountCmd,
  1098.                 deviceName);
  1099.         retval = system(cmd) == 0;
  1100.     }
  1101.     else {
  1102.         if (deviceName != NULL)
  1103.         {
  1104.             retval = Message(MSG_OKC,
  1105.                             "Unmount device <%s> now; select OK when completed",
  1106.                             deviceName) != ANS_CANCEL;
  1107.         }
  1108.         else
  1109.         if (sVolume != NULL)
  1110.         {
  1111.             retval = Message(MSG_OKC,
  1112.                             "Unmount volume <%s> now; select OK when completed",
  1113.                             sVolume) != ANS_CANCEL;
  1114.         }
  1115.         else
  1116.         {
  1117.             retval = Message(MSG_OKC,
  1118.                             "Unmount CD-ROM now; select OK when completed") !=
  1119.                             ANS_CANCEL;
  1120.         }
  1121.     }
  1122. #endif /* OS_UNIX */
  1123.  
  1124. #ifdef OS_VMS
  1125.     char  cmd[100];
  1126.     char  tmp[100];
  1127.     char* cPtr;
  1128.  
  1129.  
  1130.     if ( mountPoint == NULL || *mountPoint == '\0' ) 
  1131.         strcpy(tmp,DEFAULT_CDROM); 
  1132.     else {
  1133.         strcpy(tmp,mountPoint);
  1134.         if ( cPtr = strchr(tmp,':') ) *(cPtr+1) = '\0';
  1135.     }
  1136.     /* 
  1137.     ** Try to mount device using mount-script 
  1138.     */
  1139.  
  1140.     sprintf(cmd, "CD_DISMOUNT/UNLOAD %s",tmp);
  1141.     retval = (system(cmd) == 0);
  1142.  
  1143.      Message(MSG_OK,
  1144.         "Press the eject button on <%s>.",tmp);
  1145.  
  1146. #endif
  1147.     
  1148.     return retval;
  1149. }
  1150.  
  1151. Nlm_Boolean LIBCALL  Nlm_MountCd(Nlm_CharPtr sVolume, Nlm_CharPtr deviceName,
  1152.             Nlm_CharPtr mountPoint, Nlm_CharPtr mountCmd)
  1153. {
  1154.     Nlm_Boolean retval = FALSE;
  1155.  
  1156. #ifdef OS_UNIX
  1157.     char cmd[100];
  1158.  
  1159.     if (deviceName == NULL)
  1160.     {
  1161.         deviceName = DEFAULT_CDROM;
  1162.     }
  1163.  
  1164.     /* Try to mount device using mount-script */
  1165.     if (mountCmd != NULL)
  1166.     {
  1167.         sprintf(cmd, "%s -m %s %s >/dev/null 2>/dev/null", mountCmd, deviceName,
  1168.                 mountPoint != NULL ? mountPoint : "");
  1169.         retval = system(cmd) == 0;
  1170.     }
  1171.     else {
  1172.         if (deviceName != NULL)
  1173.         {
  1174.         }
  1175.         else
  1176.         {
  1177.             retval = Message(MSG_OKC,
  1178.                             "Mount CD-ROM now; select OK when completed") !=
  1179.                             ANS_CANCEL;
  1180.         }
  1181.     }
  1182. #endif
  1183.  
  1184. #ifdef OS_VMS
  1185.     char  cmd[100];
  1186.     char  tmp[100];
  1187.     char* cPtr;
  1188.  
  1189.  
  1190.     if ( mountPoint == NULL || *mountPoint == '\0' ) 
  1191.         strcpy(tmp,DEFAULT_CDROM); 
  1192.     else {
  1193.         strcpy(tmp,mountPoint);
  1194.         if ( cPtr = strchr(tmp,':') ) *(cPtr+1) = '\0';
  1195.     }
  1196.  
  1197.  
  1198.     /* Try to mount device using mount-script */
  1199.  
  1200.     sprintf(cmd, "CD_MOUNT/MEDIA=CDROM/OVERRIDE=IDENTIFICATION/NOASSIST %s",
  1201.           tmp);
  1202.  
  1203.     retval = (system(cmd) == 0);
  1204.  
  1205. #endif
  1206.  
  1207.     return retval;
  1208. }
  1209.  
  1210.